package org.xm.moretriggercommands;

import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;


public class Verify {

    private final List<String> errorMessages = new ArrayList<>();
    // 颜色代码正则（用于提示可能的格式错误）
    private static final Pattern COLOR_CODE_PATTERN = Pattern.compile("&[0-9a-fklmnor]");

    // 磁盘上的配置文件实例，整个类共享
    private FileConfiguration config;


    public List<String> validate() {
        errorMessages.clear();
        // 首先加载磁盘上的配置文件
        if (!loadDiskConfig()) {
            errorMessages.add("配置文件加载失败：无法读取插件目录下的config.yml");
            return errorMessages;
        }

        // 1. 验证基础设置
        validateBasicSettings();
        // 2. 验证自定义指令配置
        validateCustomizeCommand();
        // 3. 验证玩家血量相关配置
        validateLifeLessThan();
        // 4. 验证玩家死亡相关配置
        validatePlayerDeath();
        validatePlayerRespawn();
        validateKillNotifier();
        // 5. 验证玩家进服相关配置
        validateJoin();
        // 6. 验证资源包相关配置
        validateResourcePackStatus();
        // 7. 验证物品操作相关配置
        validateInventoryActions();
        // 8. 验证床相关配置
        validateBedActions();
        // 9. 验证服务器性能(TPS)配置
        validateTPSCommand();
        // 10. 验证世界切换配置
        validatePlayerChangedWorld();
        // 11. 验证区域进入检测配置
        validateJoinRegion();
        return errorMessages;
    }


    private boolean loadDiskConfig() {
        try {
            File configFile = new File(Main.getInstance().getDataFolder(), "config.yml");
            // 确保配置文件存在
            if (!configFile.exists()) {
                errorMessages.add("配置文件不存在：" + configFile.getAbsolutePath());
                return false;
            }
            config = YamlConfiguration.loadConfiguration(configFile);
            return true;
        } catch (Exception e) {
            errorMessages.add("加载配置文件时发生错误：" + e.getMessage());
            return false;
        }
    }


    // 1. 验证基础设置
    private void validateBasicSettings() {
        // 检查版本配置是否存在
        if (!config.contains("version")) {
            errorMessages.add("基础设置缺失：未找到version配置项");
        }
        // 检查更新开关是否存在及类型
        if (!config.contains("update")) {
            errorMessages.add("基础设置缺失：未找到update配置项");
        } else if (!config.isBoolean("update")) {
            errorMessages.add("基础设置错误：update必须为true/false（当前值：" + config.get("update") + "）");
        }
    }

    // 2. 验证自定义指令配置
    private void validateCustomizeCommand() {
        ConfigurationSection cmdSection = config.getConfigurationSection("CustomizeCommand");
        if (cmdSection == null) {
            errorMessages.add("自定义指令配置缺失：未找到CustomizeCommand节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!cmdSection.contains("Switch")) {
            errorMessages.add("自定义指令缺失：未找到Switch配置项");
        } else if (!cmdSection.isBoolean("Switch")) {
            errorMessages.add("自定义指令错误：Switch必须为true/false（当前值：" + cmdSection.get("Switch") + "）");
        }
        // 如果开关开启，检查指令列表
        boolean isEnabled = cmdSection.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查CCommand是否存在及是否为列表
            if (!cmdSection.contains("CCommand")) {
                errorMessages.add("自定义指令缺失：未找到CCommand指令列表");
            } else if (!cmdSection.isList("CCommand")) {
                errorMessages.add("自定义指令错误：CCommand必须为列表类型（当前值：" + cmdSection.get("CCommand") + "）");
            } else {
                // 检查每个指令是否有对应配置块
                List<String> commands = cmdSection.getStringList("CCommand");
                for (String cmd : commands) {
                    if (cmd == null || cmd.trim().isEmpty()) {
                        errorMessages.add("自定义指令错误：CCommand列表中存在空值或无效指令键");
                        continue;
                    }
                    ConfigurationSection cmdConfig = config.getConfigurationSection(cmd);
                    if (cmdConfig == null) {
                        errorMessages.add("自定义指令缺失：CCommand中包含" + cmd + "，但未找到对应的" + cmd + "配置块");
                        continue;
                    }
                    // 检查触发指令列表是否存在及类型
                    if (!cmdConfig.contains("Customize-Command")) {
                        errorMessages.add(cmd + "配置缺失：未找到Customize-Command（触发指令列表）");
                    } else if (!cmdConfig.isList("Customize-Command")) {
                        errorMessages.add(cmd + "配置错误：Customize-Command必须为列表类型");
                    }
                    // 检查执行指令列表是否存在及类型（补充遗漏的关键配置项检查）
                    if (!cmdConfig.contains("Execute-Command")) {
                        errorMessages.add(cmd + "配置缺失：未找到Execute-Command（执行指令列表）");
                    } else if (!cmdConfig.isList("Execute-Command")) {
                        errorMessages.add(cmd + "配置错误：Execute-Command必须为列表类型");
                    }
                }
            }
        }
    }

    // 3. 验证玩家血量低于阈值配置
    private void validateLifeLessThan() {
        ConfigurationSection lifeSection = config.getConfigurationSection("LifeLessThan");
        if (lifeSection == null) {
            errorMessages.add("玩家血量配置缺失：未找到LifeLessThan节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!lifeSection.contains("Switch")) {
            errorMessages.add("玩家血量配置缺失：未找到Switch配置项");
        } else if (!lifeSection.isBoolean("Switch")) {
            errorMessages.add("玩家血量错误：Switch必须为true/false（当前值：" + lifeSection.get("Switch") + "）");
        }
        boolean isEnabled = lifeSection.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查百分比是否存在及范围
            if (!lifeSection.contains("LifeLessThanPercent")) {
                errorMessages.add("玩家血量缺失：未找到LifeLessThanPercent（血量阈值百分比）");
            } else if (!lifeSection.isInt("LifeLessThanPercent")) {
                errorMessages.add("玩家血量错误：LifeLessThanPercent必须为整数（当前值：" + lifeSection.get("LifeLessThanPercent") + "）");
            } else {
                int percent = lifeSection.getInt("LifeLessThanPercent");
                if (percent < 0 || percent > 100) {
                    errorMessages.add("玩家血量错误：LifeLessThanPercent必须在0-100之间（当前值：" + percent + "）");
                }
            }
            // 检查指令列表是否存在及类型
            if (!lifeSection.contains("LifeLessThanCommand")) {
                errorMessages.add("玩家血量缺失：未找到LifeLessThanCommand（触发指令列表）");
            } else if (!lifeSection.isList("LifeLessThanCommand")) {
                errorMessages.add("玩家血量错误：LifeLessThanCommand必须为列表类型");
            }
        }
    }

    // 4.1 验证玩家死亡配置
    private void validatePlayerDeath() {
        ConfigurationSection deathSection = config.getConfigurationSection("PlayerDeath");
        if (deathSection == null) {
            errorMessages.add("玩家死亡配置缺失：未找到PlayerDeath节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!deathSection.contains("Switch")) {
            errorMessages.add("玩家死亡配置缺失：未找到Switch配置项");
        } else if (!deathSection.isBoolean("Switch")) {
            errorMessages.add("玩家死亡错误：Switch必须为true/false（当前值：" + deathSection.get("Switch") + "）");
        }
        boolean isEnabled = deathSection.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查控制台指令延迟是否存在及非负
            checkNonNegativeNumber(deathSection, "Console-Command-Cd", "玩家死亡缺失：", "控制台指令延迟");
            // 检查玩家指令延迟是否存在及非负
            checkNonNegativeNumber(deathSection, "Player-Command-Cd", "玩家死亡缺失：", "玩家指令延迟");
            // 检查时间格式是否存在及有效
            if (!deathSection.contains("Date")) {
                errorMessages.add("玩家死亡缺失：未找到Date配置项（时间格式）");
            } else {
                String dateFormat = deathSection.getString("Date");
                try {
                    new SimpleDateFormat(dateFormat);
                } catch (IllegalArgumentException e) {
                    errorMessages.add("玩家死亡错误：Date格式无效（当前值：" + dateFormat + "，示例：yyyy-MM-dd HH:mm:ss）");
                }
            }
            // 检查控制台指令列表是否存在及类型
            if (!deathSection.contains("Console-Commands")) {
                errorMessages.add("玩家死亡缺失：未找到Console-Commands（控制台指令列表）");
            } else if (!deathSection.isList("Console-Commands")) {
                errorMessages.add("玩家死亡错误：Console-Commands必须为列表类型");
            }
            // 检查玩家指令列表是否存在及类型
            if (!deathSection.contains("Player-Commands")) {
                errorMessages.add("玩家死亡缺失：未找到Player-Commands（玩家指令列表）");
            } else if (!deathSection.isList("Player-Commands")) {
                errorMessages.add("玩家死亡错误：Player-Commands必须为列表类型");
            }
        }
    }

    // 4.2 验证玩家重生配置
    private void validatePlayerRespawn() {
        ConfigurationSection respawnSection = config.getConfigurationSection("PlayerRespawn");
        if (respawnSection == null) {
            errorMessages.add("玩家重生配置缺失：未找到PlayerRespawn节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!respawnSection.contains("Switch")) {
            errorMessages.add("玩家重生配置缺失：未找到Switch配置项");
        } else if (!respawnSection.isBoolean("Switch")) {
            errorMessages.add("玩家重生错误：Switch必须为true/false（当前值：" + respawnSection.get("Switch") + "）");
        }
        boolean isEnabled = respawnSection.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查延迟数值是否存在及非负
            checkNonNegativeNumber(respawnSection, "Console-Command-Cd", "玩家重生缺失：", "控制台指令延迟");
            checkNonNegativeNumber(respawnSection, "Player-Command-Cd", "玩家重生缺失：", "玩家指令延迟");
            // 检查时间格式是否存在及有效
            if (!respawnSection.contains("Date")) {
                errorMessages.add("玩家重生缺失：未找到Date配置项（时间格式）");
            } else {
                String dateFormat = respawnSection.getString("Date");
                try {
                    new SimpleDateFormat(dateFormat);
                } catch (IllegalArgumentException e) {
                    errorMessages.add("玩家重生错误：Date格式无效（当前值：" + dateFormat + "）");
                }
            }
            // 检查指令列表是否存在及类型
            if (!respawnSection.contains("Console-Commands")) {
                errorMessages.add("玩家重生缺失：未找到Console-Commands（控制台指令列表）");
            } else if (!respawnSection.isList("Console-Commands")) {
                errorMessages.add("玩家重生错误：Console-Commands必须为列表类型");
            }
            if (!respawnSection.contains("Player-Commands")) {
                errorMessages.add("玩家重生缺失：未找到Player-Commands（玩家指令列表）");
            } else if (!respawnSection.isList("Player-Commands")) {
                errorMessages.add("玩家重生错误：Player-Commands必须为列表类型");
            }
        }
    }

    // 4.3 验证玩家击杀通知配置
    private void validateKillNotifier() {
        ConfigurationSection killSection = config.getConfigurationSection("KillNotifier");
        if (killSection == null) {
            errorMessages.add("击杀通知配置缺失：未找到KillNotifier节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!killSection.contains("Switch")) {
            errorMessages.add("击杀通知配置缺失：未找到Switch配置项");
        } else if (!killSection.isBoolean("Switch")) {
            errorMessages.add("击杀通知错误：Switch必须为true/false（当前值：" + killSection.get("Switch") + "）");
        }
        boolean isEnabled = killSection.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查指令列表是否存在及类型
            if (!killSection.contains("KillNotifierCommand")) {
                errorMessages.add("击杀通知缺失：未找到KillNotifierCommand（通知指令列表）");
            } else if (!killSection.isList("KillNotifierCommand")) {
                errorMessages.add("击杀通知错误：KillNotifierCommand必须为列表类型");
            } else {
                // 检查变量是否正确
                List<String> cmds = killSection.getStringList("KillNotifierCommand");
                for (String cmd : cmds) {
                    if (!cmd.contains("%player_name%") || !cmd.contains("%Drop_name%")) {
                        errorMessages.add("击杀通知警告：指令可能缺少必要变量（%player_name%或%Drop_name%，当前指令：" + cmd + "）");
                    }
                }
            }
        }
    }

    // 5. 验证玩家进服配置
    private void validateJoin() {
        ConfigurationSection joinSection = config.getConfigurationSection("Join");
        if (joinSection == null) {
            errorMessages.add("进服配置缺失：未找到Join节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!joinSection.contains("Switch")) {
            errorMessages.add("进服配置缺失：未找到Switch配置项");
        } else if (!joinSection.isBoolean("Switch")) {
            errorMessages.add("进服配置错误：Switch必须为true/false（当前值：" + joinSection.get("Switch") + "）");
        }
        boolean isEnabled = joinSection.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查首次进服指令列表是否存在及类型
            if (!joinSection.contains("FirstCommand")) {
                errorMessages.add("进服配置缺失：未找到FirstCommand（首次进服指令列表）");
            } else if (!joinSection.isList("FirstCommand")) {
                errorMessages.add("进服配置错误：FirstCommand必须为列表类型");
            }
            // 检查常规进服指令列表是否存在及类型
            if (!joinSection.contains("EnterCommands")) {
                errorMessages.add("进服配置缺失：未找到EnterCommands（常规进服指令列表）");
            } else if (!joinSection.isList("EnterCommands")) {
                errorMessages.add("进服配置错误：EnterCommands必须为列表类型");
            }
        }
    }

    // 6. 验证资源包状态配置
    private void validateResourcePackStatus() {
        ConfigurationSection rpSection = config.getConfigurationSection("ResourcePackStatus");
        if (rpSection == null) {
            errorMessages.add("资源包配置缺失：未找到ResourcePackStatus节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!rpSection.contains("Switch")) {
            errorMessages.add("资源包配置缺失：未找到Switch配置项");
        } else if (!rpSection.isBoolean("Switch")) {
            errorMessages.add("资源包配置错误：Switch必须为true/false（当前值：" + rpSection.get("Switch") + "）");
        }
        boolean isEnabled = rpSection.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查四个状态的指令列表是否存在及类型
            String[] cmdKeys = {
                    "SUCCESSFULLY_LOADEDCommands",  // 加载成功指令
                    "FAILED_DOWNLOADCommands",      // 下载失败指令
                    "DECLINEDCommands",              // 拒绝加载指令
                    "ACCEPTEDCommands"               // 接受加载指令
            };
            for (String key : cmdKeys) {
                if (!rpSection.contains(key)) {
                    errorMessages.add("资源包配置缺失：未找到" + key + "（对应状态的指令列表）");
                } else if (!rpSection.isList(key)) {
                    errorMessages.add("资源包配置错误：" + key + "必须为列表类型");
                }
            }
        }
    }

    // 7. 验证物品操作配置（打开/关闭背包、丢物品）
    private void validateInventoryActions() {
        // 验证打开背包
        validateSimpleAction("InventoryOpen", "打开背包", "打开背包时执行的指令列表");
        // 验证关闭背包
        validateSimpleAction("InventoryClose", "关闭背包", "关闭背包时执行的指令列表");
        // 验证丢物品
        ConfigurationSection dropConfig = config.getConfigurationSection("PlayerDropItem");
        if (dropConfig == null) {
            errorMessages.add("丢物品配置缺失：未找到PlayerDropItem节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!dropConfig.contains("Switch")) {
            errorMessages.add("丢物品配置缺失：未找到Switch配置项");
        } else if (!dropConfig.isBoolean("Switch")) {
            errorMessages.add("丢物品配置错误：Switch必须为true/false（当前值：" + dropConfig.get("Switch") + "）");
        }
        boolean isEnabled = dropConfig.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查指令列表是否存在及类型
            if (!dropConfig.contains("PlayerDropItem")) {
                errorMessages.add("丢物品配置缺失：未找到PlayerDropItem（丢物品时执行的指令列表）");
            } else if (!dropConfig.isList("PlayerDropItem")) {
                errorMessages.add("丢物品配置错误：PlayerDropItem必须为列表类型");
            } else {
                List<String> cmds = dropConfig.getStringList("PlayerDropItem");
                for (String cmd : cmds) {
                    if (!cmd.contains("%Drop_name%")) {
                        errorMessages.add("丢物品配置警告：指令可能缺少%Drop_name%变量（当前指令：" + cmd + "）");
                    }
                }
            }
        }
    }

    // 8. 验证床操作配置（上床/下床）
    private void validateBedActions() {
        validateSimpleAction("PlayerBedEnter", "上床", "上床时执行的指令列表");
        validateSimpleAction("PlayerBedLeave", "下床", "下床时执行的指令列表");
    }

    // 9. 验证TPS配置
    private void validateTPSCommand() {
        ConfigurationSection tpsSection = config.getConfigurationSection("TPScommand");
        if (tpsSection == null) {
            errorMessages.add("TPS配置缺失：未找到TPScommand节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!tpsSection.contains("Switch")) {
            errorMessages.add("TPS配置缺失：未找到Switch配置项");
        } else if (!tpsSection.isBoolean("Switch")) {
            errorMessages.add("TPS配置错误：Switch必须为true/false（当前值：" + tpsSection.get("Switch") + "）");
        }
        boolean isEnabled = tpsSection.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查TPStime（固定20，不允许修改）
            if (tpsSection.contains("TPStime") && tpsSection.getInt("TPStime") != 20) {
                errorMessages.add("TPS配置错误：TPStime必须为20（插件硬性规定，请勿修改）");
            }
            // 检查TPS阈值是否存在及范围
            if (!tpsSection.contains("TPSBelow")) {
                errorMessages.add("TPS配置缺失：未找到TPSBelow（TPS阈值，低于此值触发指令）");
            } else if (!tpsSection.isInt("TPSBelow")) {
                errorMessages.add("TPS配置错误：TPSBelow必须为整数（当前值：" + tpsSection.get("TPSBelow") + "）");
            } else {
                int tps = tpsSection.getInt("TPSBelow");
                if (tps < 0 || tps > 20) {
                    errorMessages.add("TPS配置错误：TPSBelow必须在0-20之间（当前值：" + tps + "）");
                }
            }
            // 检查冷却时间是否存在及非负
            checkNonNegativeNumber(tpsSection, "Cooldown", "TPS配置缺失：", "指令冷却时间（秒）");
            // 检查指令列表是否存在及类型
            if (!tpsSection.contains("TPScommand")) {
                errorMessages.add("TPS配置缺失：未找到TPScommand（TPS低于阈值时执行的指令列表）");
            } else if (!tpsSection.isList("TPScommand")) {
                errorMessages.add("TPS配置错误：TPScommand必须为列表类型");
            }
        }
    }

    // 10. 验证世界切换配置
    private void validatePlayerChangedWorld() {
        validateSimpleAction("PlayerChangedWorld", "世界切换", "世界切换时执行的指令列表");
    }

    // 11. 验证区域进入检测配置
    private void validateJoinRegion() {
        ConfigurationSection regionSection = config.getConfigurationSection("JoinRegion");
        if (regionSection == null) {
            errorMessages.add("区域检测配置缺失：未找到JoinRegion节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!regionSection.contains("Switch")) {
            errorMessages.add("区域检测配置缺失：未找到Switch配置项");
        } else if (!regionSection.isBoolean("Switch")) {
            errorMessages.add("区域检测错误：Switch必须为true/false（当前值：" + regionSection.get("Switch") + "）");
        }
        boolean isEnabled = regionSection.getBoolean("Switch", false);
        if (isEnabled) {
            // 检查区域ID列表是否存在及类型
            if (!regionSection.contains("Region")) {
                errorMessages.add("区域检测缺失：未找到Region（区域ID列表，需包含所有要检测的区域键名）");
            } else if (!regionSection.isList("Region")) {
                errorMessages.add("区域检测错误：Region必须为列表类型（区域ID列表）");
            } else {
                List<String> regions = regionSection.getStringList("Region");
                for (String regionId : regions) {
                    if (regionId == null || regionId.trim().isEmpty()) {
                        errorMessages.add("区域检测错误：Region列表中存在空值或无效区域ID");
                        continue;
                    }
                    ConfigurationSection regionConfig = config.getConfigurationSection(regionId);
                    if (regionConfig == null) {
                        errorMessages.add("区域检测缺失：Region列表包含" + regionId + "，但未找到对应的" + regionId + "配置块");
                        continue;
                    }
                    // 检查区域名称是否存在
                    if (!regionConfig.contains("RegionName")) {
                        errorMessages.add(regionId + "配置缺失：未找到RegionName（区域显示名称，用于提示）");
                    }
                    // 检查世界名称是否存在及非空
                    if (!regionConfig.contains("RegionWorld")) {
                        errorMessages.add(regionId + "配置缺失：未找到RegionWorld（区域所在的世界名称）");
                    } else {
                        String world = regionConfig.getString("RegionWorld");
                        if (world == null || world.trim().isEmpty()) {
                            errorMessages.add(regionId + "配置错误：RegionWorld（世界名称）不能为空");
                        }
                    }
                    // 检查区域坐标是否存在及有效
                    checkRegionCorner(regionConfig, "corner1", regionId, "区域第一个角点坐标（x,z）");
                    checkRegionCorner(regionConfig, "corner2", regionId, "区域第二个角点坐标（x,z）");
                    // 检查进入/退出指令列表是否存在及类型
                    if (!regionConfig.contains("Join-Command")) {
                        errorMessages.add(regionId + "配置缺失：未找到Join-Command（进入区域时执行的指令列表）");
                    } else if (!regionConfig.isList("Join-Command")) {
                        errorMessages.add(regionId + "配置错误：Join-Command必须为列表类型");
                    }
                    if (!regionConfig.contains("Exit-Command")) {
                        errorMessages.add(regionId + "配置缺失：未找到Exit-Command（退出区域时执行的指令列表）");
                    } else if (!regionConfig.isList("Exit-Command")) {
                        errorMessages.add(regionId + "配置错误：Exit-Command必须为列表类型");
                    }
                }
            }
        }
    }


    // ------------------------------
    // 工具方法
    // ------------------------------

    /**
     * 验证简单动作配置（包含开关和单指令列表的配置，如打开背包、上床等）
     * @param node 配置节点名称（如InventoryOpen）
     * @param desc 配置描述（用于错误信息）
     * @param cmdDesc 指令列表的描述（用于缺失提示）
     */
    private void validateSimpleAction(String node, String desc, String cmdDesc) {
        ConfigurationSection actionSection = config.getConfigurationSection(node);
        if (actionSection == null) {
            errorMessages.add(desc + "配置缺失：未找到" + node + "节点");
            return;
        }
        // 检查开关是否存在及类型
        if (!actionSection.contains("Switch")) {
            errorMessages.add(desc + "配置缺失：未找到Switch配置项");
        } else if (!actionSection.isBoolean("Switch")) {
            errorMessages.add(desc + "配置错误：Switch必须为true/false（当前值：" + actionSection.get("Switch") + "）");
        }
        boolean isEnabled = actionSection.getBoolean("Switch", false);
        if (isEnabled) {
            String cmdKey = node; // 指令列表键名与节点名相同
            // 检查指令列表是否存在及类型
            if (!actionSection.contains(cmdKey)) {
                errorMessages.add(desc + "配置缺失：未找到" + cmdKey + "（" + cmdDesc + "）");
            } else if (!actionSection.isList(cmdKey)) {
                errorMessages.add(desc + "配置错误：" + cmdKey + "必须为列表类型");
            }
        }
    }


    private void checkRegionCorner(ConfigurationSection regionConfig, String corner, String regionId, String cornerDesc) {
        if (!regionConfig.contains(corner)) {
            errorMessages.add(regionId + "配置缺失：未找到" + corner + "（" + cornerDesc + "）");
            return;
        }
        ConfigurationSection cornerConfig = regionConfig.getConfigurationSection(corner);
        if (cornerConfig == null) {
            errorMessages.add(regionId + "配置错误：" + corner + "必须为节点类型（包含x和z坐标）");
            return;
        }
        // 检查x坐标是否存在及类型
        if (!cornerConfig.contains("x")) {
            errorMessages.add(regionId + "配置缺失：" + corner + ".x（" + cornerDesc + "的x坐标）");
        } else if (!cornerConfig.isInt("x")) {
            errorMessages.add(regionId + "配置错误：" + corner + ".x必须为整数（当前值：" + cornerConfig.get("x") + "）");
        }
        // 检查z坐标是否存在及类型
        if (!cornerConfig.contains("z")) {
            errorMessages.add(regionId + "配置缺失：" + corner + ".z（" + cornerDesc + "的z坐标）");
        } else if (!cornerConfig.isInt("z")) {
            errorMessages.add(regionId + "配置错误：" + corner + ".z必须为整数（当前值：" + cornerConfig.get("z") + "）");
        }
    }


    private void checkNonNegativeNumber(ConfigurationSection config, String key, String prefix, String keyDesc) {
        if (!config.contains(key)) {
            errorMessages.add(prefix + "未找到" + key + "（" + keyDesc + "）");
        } else if (!config.isInt(key)) {
            errorMessages.add(prefix + key + "必须为整数（当前值：" + config.get(key) + "）");
        } else {
            int value = config.getInt(key);
            if (value < 0) {
                errorMessages.add(prefix + key + "不能为负数（当前值：" + value + "）");
            }
        }
    }
}